home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / doom / ldhe-src.0 / ldhe-src / dehacked / source / x11_keyboard.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-20  |  3.8 KB  |  195 lines
  1.  
  2. #include <sys/time.h>
  3. #include <stdio.h>
  4.  
  5. #include "keyboard.h"
  6.  
  7.  
  8. X11_Keyboard:: X11_Keyboard(Display** D) : TTY_Keyboard()
  9. {
  10.     display  = D;
  11.     extended = 0;
  12. }
  13.  
  14. // X11 raw/cooked doesn't mean anything.
  15. int
  16. X11_Keyboard:: raw(int newstate)
  17. {
  18.     keyboard_state = newstate;
  19.     return(0);
  20. }
  21.  
  22. // Kind of a kludge, we either block or don't block, nothing in between.
  23. int
  24. X11_Keyboard:: pending_input(float do_wait)
  25. {
  26.     XEvent event;
  27.     int pending;
  28.  
  29.     if ( ! *display )
  30.         return(TTY_Keyboard::pending_input(do_wait));
  31.     
  32.     /* Check the pending input */
  33.     if ( ! do_wait ) {
  34.         pending = XPending(*display);
  35.         while ( pending ) {
  36.             XNextEvent(*display, &event);
  37.             if ( event.type == KeyPress )
  38.                 return(1);
  39.         }
  40.         return(0);
  41.     }
  42.         
  43.     // Block until we recieve input.
  44.     for ( ; ; ) {
  45.         // Get the next event
  46.         XPeekEvent(*display, &event);
  47.  
  48.         // Check if keypress, if not, suck it up.
  49.         if ( event.type == KeyPress )
  50.             return(1);
  51.         else {
  52.             XNextEvent(*display, &event);
  53.             switch (event.type) {
  54.  
  55.                 case Expose:
  56.                     if ( do_refresh )
  57.                         (*App_Refresh)();
  58.                     break;
  59.                 default:    // Ignore the event
  60.                     break;
  61.             }
  62.         }
  63.                 
  64.     }
  65.     /* NOTREACHED */
  66. }
  67.  
  68.  
  69. int
  70. X11_Keyboard:: ExtendKey(KeySym key)
  71. {
  72. static struct { KeySym sym; char *string; int value; } func_keys[] = {
  73.     { XK_F1,    "~",     F1 },
  74.     { XK_F2,    "~",     F2 },
  75.     { XK_F3,    "~",     F3 },
  76.     { XK_F4,    "~",     F4 },
  77.     { XK_F5,    "~",     F5 },
  78.     { XK_F6,    "~",     F6 },
  79.     { XK_F7,    "~",     F7 },
  80.     { XK_F8,    "~",     F8 },
  81.     { XK_Up,    "A",     UP },
  82.     { XK_Page_Up,    "~",     PGUP },
  83.     { XK_Left,    "D",     LEFT },
  84.     { XK_Right,    "C",     RIGHT },
  85.     { XK_Down,    "B",     DOWN },
  86.     { XK_Page_Down,    "~",     PGDN },
  87.     { XK_Home,    "H",         HOME },
  88.     { XK_End,    "Ow",     END },
  89. /* Terminate the list */
  90.     { 0, NULL, 0 } };
  91.  
  92.     // Otherwise, it's a complex function key:
  93.     for ( int i=0; func_keys[i].string; ++i ) {
  94.         if ( key == func_keys[i].sym )
  95.             return(func_keys[i].value);
  96.     }
  97.     return(0);
  98. }
  99.  
  100. int
  101. X11_Keyboard:: getch(void)
  102. {
  103.     XEvent event;
  104.     int count;
  105.     char key_string[256];
  106.     int pending;
  107.     KeySym keysym;
  108.     XComposeStatus compose;
  109.  
  110.     // If we don't have a display, just return characters from tty.
  111.     if ( ! *display )
  112.         return(TTY_Keyboard::getch());
  113.  
  114.     /* If there is an extended key, return it. */
  115.     if ( extended ) {
  116.         pending = ExtendKey(extended);
  117.         extended = 0;
  118.         return(pending);
  119.     }
  120.  
  121.     for ( pending=0, count=0; count == 0; )
  122.     {
  123.         /* Wait here for an event and then get the number waiting */
  124.         XPeekEvent(*display, &event);  /* This function blocks */
  125.         pending = XPending(*display);
  126.         
  127.         /* Handle any events pending */
  128.         while (pending > 0)
  129.         {
  130.             /* Get the next X event thanks */
  131.             XNextEvent(*display, &event);
  132.  
  133.             switch(event.type)
  134.             {
  135. #ifdef WE_HAVE_AN_EVENT_MASK
  136.                 case UnmapNotify:
  137.                     /* Turn off just all events except the mapping ones */
  138.                         XSelectInput(*display, MainWin, StructureNotifyMask);
  139.                     break;
  140.  
  141.                 case MapNotify:
  142.                     /* Turn back on all the events 
  143.                             that are needed */
  144.                         XSelectInput(*display, MainWin, 
  145.                                 Event_mask);
  146.                     break;
  147. #endif /* WE_HAVE_AN_EVENT_MASK */
  148.  
  149.                 case Expose:
  150.                     if ( do_refresh )
  151.                         (*App_Refresh)();
  152.                     break;
  153. #ifdef HANDLE_MOUSE
  154.                 case ButtonRelease:
  155.                     handleMouseButtons(*display, event, False);
  156.                     break;
  157.  
  158.                 case ButtonPress:
  159.                     handleMouseButtons(*display, event, True);
  160.                     break;
  161.  
  162.                 case MotionNotify:
  163.                     handleMouseMotion(*display, event);
  164.                     break;
  165. #endif /* HANDLE_MOUSE */
  166.  
  167. #ifdef HANDLE_KEYRELEASE
  168.                 case KeyRelease:
  169.                     keysym = GetKeySym(event);
  170.                     handleKeyPress(*display, keysym, event, False);
  171.                     break;
  172. #endif /* HANDLE_KEYRELEASE */
  173.  
  174.                 case KeyPress:
  175.                     count = 
  176.     XLookupString(&event.xkey, key_string, 256, &keysym, &compose);
  177.                     goto pressedkey;
  178.  
  179.                 default:
  180.                     break;
  181.             }
  182.  
  183.             /* Decrement the number of pending events */
  184.             pending--;
  185.         }
  186.     }
  187.  
  188.   pressedkey:
  189.     if ( count ) 
  190.         return(key_string[0]);
  191.  
  192.     extended = keysym;
  193.     return(0);
  194. }
  195.